// 多重继承(MI)设计模式详解
// 多重继承(Multiple Inheritance, MI)是C++中的一个强大特性，它允许一个类从多个基类继承。虽然有争议，但当正确应用时，MI可以创建优雅而强大的设计模式。以下是几种常见的MI设计模式：

// 1. 接口分离与实现继承模式
// 这种模式结合了接口继承和实现继承，分离了"是什么"和"如何做"。
// 接口类
class IDrawable
{
public:
    virtual ~IDrawable() = default;
    virtual void draw() const = 0;
};

// 实现类
class DrawingImplementation
{
protected:
    void drawLine(int x1, int y1, int x2, int y2) const
    {
        // 实现绘制线条的代码
    }
    void drawCircle(int x, int y, int radius) const
    {
        // 实现绘制圆的代码
    }
};

// 使用多重继承组合接口和实现
class Circle : public IDrawable, private DrawingImplementation
{
private:
    int x, y, radius;

public:
    Circle(int x, int y, int r) : x(x), y(y), radius(r) {}

    // 实现接口，使用实现类提供的功能
    void draw() const override
    {
        drawCircle(x, y, radius);
    }
};
// 优点：
// 分离接口和实现
// 允许接口和实现独立演化
// 实现代码可以在多个类之间共享

// 2. Mixin模式
// Mixin模式使用多重继承来组合独立的、可重用的功能。
// 日志功能Mixin
class Loggable
{
public:
    void log(const std::string &message) const
    {
        std::cout << "[LOG] " << message << std::endl;
    }
};

// 持久化功能Mixin
class Persistable
{
public:
    void save(const std::string &filename) const
    {
        // 保存对象到文件
    }

    void load(const std::string &filename)
    {
        // 从文件加载对象
    }
};

// 组合多个Mixin
class User : public Loggable, public Persistable
{
private:
    std::string name;
    std::string email;

public:
    User(const std::string &n, const std::string &e) : name(n), email(e)
    {
        log("User created: " + name);
    }

    void updateEmail(const std::string &newEmail)
    {
        email = newEmail;
        log("Email updated for user: " + name);
        save("users.dat");
    }
};
// 优点：
// 功能组合的灵活性
// 代码重用
// 避免深层继承层次

// 3. 策略组合模式
// 使用多重继承组合多个策略类，特别适合与空基类优化(EBO)结合使用。
// 内存分配策略
template <typename T>
class MallocAllocator
{
protected:
    T *allocate(size_t n)
    {
        return static_cast<T *>(malloc(n * sizeof(T)));
    }

    void deallocate(T *p)
    {
        free(p);
    }
};

// 线程安全策略
template <typename T>
class MutexLock
{
private:
    mutable std::mutex mutex;

protected:
    void lock() const { mutex.lock(); }
    void unlock() const { mutex.unlock(); }
};

// 组合多个策略
template <typename T>
class ThreadSafeVector : private MallocAllocator<T>, private MutexLock<T>
{
private:
    T *data;
    size_t size;
    size_t capacity;

public:
    // 使用基类策略实现线程安全的向量
    void push_back(const T &value)
    {
        this->lock(); // 来自MutexLock

        if (size == capacity)
        {
            size_t newCapacity = capacity == 0 ? 1 : capacity * 2;
            T *newData = this->allocate(newCapacity); // 来自MallocAllocator

            // 复制数据...

            this->deallocate(data); // 来自MallocAllocator
            data = newData;
            capacity = newCapacity;
        }

        data[size++] = value;
        this->unlock(); // 来自MutexLock
    }

    // 其他方法...
};
// 优点：
// 灵活组合多种策略
// 通过EBO减少内存开销
// 静态多态性，无运行时开销

// 4. 桥接实现模式
// 使用MI实现桥接模式的变体，将抽象和实现分离。
// 平台特定实现
class WindowsImpl
{
protected:
    void platformDraw() { /* Windows绘图代码 */ }
    void platformResize() { /* Windows调整大小代码 */ }
};

class LinuxImpl
{
protected:
    void platformDraw() { /* Linux绘图代码 */ }
    void platformResize() { /* Linux调整大小代码 */ }
};

// 形状抽象
class Shape
{
public:
    virtual void draw() = 0;
    virtual void resize(int width, int height) = 0;
    virtual ~Shape() = default;
};

// 使用多重继承桥接抽象和实现
#ifdef _WIN32
class Rectangle : public Shape, private WindowsImpl
{
#else
class Rectangle : public Shape, private LinuxImpl
{
#endif
private:
    int width, height;

public:
    Rectangle(int w, int h) : width(w), height(h) {}

    void draw() override
    {
        platformDraw(); // 调用平台特定实现
    }

    void resize(int w, int h) override
    {
        width = w;
        height = h;
        platformResize(); // 调用平台特定实现
    }
};
// 优点：
// 编译时平台选择
// 无虚函数调用开销
// 紧密集成平台特定代码

// 5. 接口聚合模式
// 组合多个接口创建更复杂的接口。
// 基本接口
class IClickable
{
public:
    virtual void onClick() = 0;
    virtual ~IClickable() = default;
};

class IDraggable
{
public:
    virtual void onDragStart() = 0;
    virtual void onDragEnd() = 0;
    virtual ~IDraggable() = default;
};

// 组合接口
class IInteractive : public IClickable, public IDraggable
{
public:
    virtual void onHover() = 0;
    virtual ~IInteractive() = default;
};

// 实现组合接口
class Button : public IInteractive
{
public:
    void onClick() override { /* 处理点击 */ }
    void onDragStart() override { /* 处理拖动开始 */ }
    void onDragEnd() override { /* 处理拖动结束 */ }
    void onHover() override { /* 处理悬停 */ }
};